package com.mxw.gateway.filter;

/** @Description TODO @Author RingKo @Date 2022/6/2 10:44 @Version 1.0 */
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONUtil;
import com.alibaba.csp.sentinel.util.StringUtil;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.core.ResolvableType;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.multipart.FilePart;
import org.springframework.http.codec.multipart.Part;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.*;

/** 日志过滤器，用于记录日志 */
@Slf4j
@Component
public class AccessLogFilter implements GlobalFilter, Ordered {
  @Override
  public int getOrder() {
    // -1 is response write filter, must be called before that
    return -100;
  }

  private final List<HttpMessageReader<?>> messageReaders =
      HandlerStrategies.withDefaults().messageReaders();

  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    ServerHttpRequest request = exchange.getRequest();
    // 请求路径
    String requestPath = request.getPath().pathWithinApplication().value();
    Route route = getGatewayRoute(exchange);
    String ipAddress = this.getIpAddress(request);

    GatewayLog gatewayLog = new GatewayLog();
    gatewayLog.setSchema(request.getURI().getScheme());
    gatewayLog.setRequestMethod(request.getMethodValue());
    gatewayLog.setRequestPath(requestPath);
    gatewayLog.setTargetServer(route == null ? "" : route.getId());
    gatewayLog.setRequestTime(new Date());
    gatewayLog.setIp(ipAddress);

    MediaType mediaType = request.getHeaders().getContentType();

    if (HttpMethod.GET.equals(request.getMethod())) {
      return writeBasicLog(exchange, chain, gatewayLog);
    } else {
      if (MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType)) {
        ResolvableType resolvableType =
            ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, Part.class);
        return DataBufferUtils.join(exchange.getRequest().getBody())
            .flatMap(
                dataBuffer -> {
                  DataBufferUtils.retain(dataBuffer);
                  final Flux<DataBuffer> cachedFlux =
                      Flux.defer(
                          () -> Flux.just(dataBuffer.slice(0, dataBuffer.readableByteCount())));
                  final ServerHttpRequest mutatedRequest =
                      new ServerHttpRequestDecorator(exchange.getRequest()) {
                        @Override
                        public Flux<DataBuffer> getBody() {
                          return cachedFlux;
                        }
                      };
                  final ServerWebExchange mutatedExchange =
                      exchange.mutate().request(mutatedRequest).build();
                  return writeMultipartFormDataLog(
                      mutatedExchange, chain, gatewayLog, resolvableType);
                });
      } else {
        return writeBodyLog(exchange, chain, gatewayLog);
      }
    }
  }

  private Mono<Void> writeBasicLog(
      ServerWebExchange exchange, GatewayFilterChain chain, GatewayLog accessLog) {
    StringBuilder builder = new StringBuilder();
    MultiValueMap<String, String> queryParams = exchange.getRequest().getQueryParams();
    for (Map.Entry<String, List<String>> entry : queryParams.entrySet()) {
      builder
          .append(entry.getKey())
          .append("=")
          .append(CharSequenceUtil.join(",", entry.getValue()));
    }
    accessLog.setRequestBody(builder.toString());

    // 获取响应体
    ServerHttpResponseDecorator decoratedResponse = recordResponseLog(exchange, accessLog);

    return chain
        .filter(exchange.mutate().response(decoratedResponse).build())
        .then(Mono.fromRunnable(() -> writeAccessLog(accessLog)));
  }

  @SuppressWarnings({"rawtypes", "unchecked"})
  private Mono<Void> writeMultipartFormDataLog(
      ServerWebExchange exchange,
      GatewayFilterChain chain,
      GatewayLog gatewayLog,
      ResolvableType resolvableType) {
    return messageReaders.stream()
        .filter(
            reader ->
                reader.canRead(resolvableType, exchange.getRequest().getHeaders().getContentType()))
        .findFirst()
        .orElseThrow(() -> new IllegalStateException("no suitable HttpMessageReader."))
        .readMono(resolvableType, exchange.getRequest(), Collections.emptyMap())
        .flatMap(
            resolvedBody -> {
              // 记录请求参数
              if (resolvedBody instanceof MultiValueMap) {
                Map<String, Object> requestParamsMap = new HashMap<>();
                MultiValueMap map = (MultiValueMap) resolvedBody;
                map.forEach(
                    (k, v) -> {
                      if (((ArrayList) v).get(0) instanceof FilePart) {
                        List<String> list = new ArrayList();
                        ((ArrayList) v)
                            .forEach(
                                item -> {
                                  FilePart filePart = (FilePart) item;
                                  list.add(filePart.filename());
                                });
                        requestParamsMap.put(k.toString(), list);
                      } else {
                        List<String> list = new ArrayList();
                        ((ArrayList) v)
                            .forEach(
                                item -> {
                                  Part part = (Part) item;
                                  Flux<DataBuffer> body = part.content();
                                  body.subscribe(
                                      buffer -> {
                                        byte[] bytes = new byte[buffer.readableByteCount()];
                                        buffer.read(bytes);
                                        DataBufferUtils.release(buffer);
                                        String bodyString =
                                            (new String(bytes, StandardCharsets.UTF_8))
                                                .replaceAll("\\s*|\\t|\\r|\\n", "");
                                        list.add(bodyString);
                                      });
                                });
                        requestParamsMap.put(k.toString(), list);
                      }
                    });
                gatewayLog.setRequestBody(requestParamsMap.toString());
              } else {
                String value = (String) resolvedBody;
                gatewayLog.setRequestBody(value);
              }
              // 获取响应体
              ServerHttpResponseDecorator decoratedResponse =
                  recordResponseLog(exchange, gatewayLog);
              return chain
                  .filter(exchange.mutate().response(decoratedResponse).build())
                  .then(Mono.fromRunnable(() -> writeAccessLog(gatewayLog)));
            });
  }

  /**
   * 解决 request body 只能读取一次问题， 参考:
   * org.springframework.cloud.gateway.filter.factory.rewrite.ModifyRequestBodyGatewayFilterFactory
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  private Mono<Void> writeBodyLog(
      ServerWebExchange exchange, GatewayFilterChain chain, GatewayLog gatewayLog) {
    ServerRequest serverRequest = ServerRequest.create(exchange, messageReaders);

    Mono<String> modifiedBody =
        serverRequest
            .bodyToMono(String.class)
            .flatMap(
                body -> {
                  gatewayLog.setRequestBody(body.replaceAll("\\s*|\\t|\\r|\\n", ""));
                  return Mono.just(body);
                });

    // 通过 BodyInserter 插入 body(支持修改body), 避免 request body 只能获取一次
    BodyInserter bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
    HttpHeaders headers = new HttpHeaders();
    headers.putAll(exchange.getRequest().getHeaders());
    // the new content type will be computed by bodyInserter
    // and then set in the request decorator
    headers.remove(HttpHeaders.CONTENT_LENGTH);

    CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);

    return bodyInserter
        .insert(outputMessage, new BodyInserterContext())
        .then(
            Mono.defer(
                () -> {
                  // 重新封装请求
                  ServerHttpRequest decoratedRequest =
                      requestDecorate(exchange, headers, outputMessage);

                  // 记录响应日志
                  ServerHttpResponseDecorator decoratedResponse =
                      recordResponseLog(exchange, gatewayLog);

                  // 记录普通的
                  return chain
                      .filter(
                          exchange
                              .mutate()
                              .request(decoratedRequest)
                              .response(decoratedResponse)
                              .build())
                      .then(Mono.fromRunnable(() -> writeAccessLog(gatewayLog)));
                }));
  }

  /**
   * 打印日志
   *
   * @date 2021/3/24 14:53
   * @param gatewayLog 网关日志
   */
  private void writeAccessLog(GatewayLog gatewayLog) {
    String json =
        JSONUtil.toJsonStr(
            gatewayLog, JSONConfig.create().setDateFormat(DatePattern.ISO8601_PATTERN));
    log.info(JSONUtil.toJsonPrettyStr(json));
  }

  private Route getGatewayRoute(ServerWebExchange exchange) {
    return exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
  }

  /** 请求装饰器，重新计算 headers */
  private ServerHttpRequestDecorator requestDecorate(
      ServerWebExchange exchange, HttpHeaders headers, CachedBodyOutputMessage outputMessage) {
    return new ServerHttpRequestDecorator(exchange.getRequest()) {
      @Override
      public HttpHeaders getHeaders() {
        long contentLength = headers.getContentLength();
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.putAll(super.getHeaders());
        if (contentLength > 0) {
          httpHeaders.setContentLength(contentLength);
        } else {
          // TODO: this causes a 'HTTP/1.1 411 Length Required' // on
          // httpbin.org
          httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
        }
        return httpHeaders;
      }

      @Override
      public Flux<DataBuffer> getBody() {
        return outputMessage.getBody();
      }
    };
  }

  /** 记录响应日志 通过 DataBufferFactory 解决响应体分段传输问题。 */
  @SuppressWarnings({"null"})
  private ServerHttpResponseDecorator recordResponseLog(
      ServerWebExchange exchange, GatewayLog gatewayLog) {
    ServerHttpResponse response = exchange.getResponse();
    DataBufferFactory bufferFactory = response.bufferFactory();

    return new ServerHttpResponseDecorator(response) {
      @Override
      public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
        if (body instanceof Flux) {
          Date responseTime = new Date();
          gatewayLog.setResponseTime(responseTime);
          // 计算执行时间
          long executeTime = (responseTime.getTime() - gatewayLog.getRequestTime().getTime());

          gatewayLog.setExecuteTime(executeTime);

          // 获取响应类型，如果是 json 就打印
          String originalResponseContentType =
              exchange.getAttribute(ServerWebExchangeUtils.ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR);

          if (ObjectUtil.equal(this.getStatusCode(), HttpStatus.OK)
              && StringUtil.isNotBlank(originalResponseContentType)
              && originalResponseContentType.contains("application/json")) {

            Flux<? extends DataBuffer> fluxBody = Flux.from(body);
            return super.writeWith(
                fluxBody
                    .buffer()
                    .map(
                        dataBuffers -> {
                          // 合并多个流集合，解决返回体分段传输
                          DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
                          DataBuffer join = dataBufferFactory.join(dataBuffers);
                          byte[] content = new byte[join.readableByteCount()];
                          join.read(content);

                          // 释放掉内存
                          DataBufferUtils.release(join);
                          String responseResult = new String(content, StandardCharsets.UTF_8);

                          gatewayLog.setResponseData(responseResult);

                          return bufferFactory.wrap(content);
                        }));
          }
        }
        // if body is not a flux. never got there.
        return super.writeWith(body);
      }
    };
  }

  private String getIpAddress(ServerHttpRequest request) {
    HttpHeaders headers = request.getHeaders();
    String ip = headers.getFirst("x-forwarded-for");
    String unknown = "unknown";
    if (ip != null && ip.length() != 0 && !unknown.equalsIgnoreCase(ip) && ip.contains(",")) {
      // 多次反向代理后会有多个ip值，第一个ip才是真实ip
      ip = ip.split(",")[0];
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      ip = headers.getFirst("Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      ip = headers.getFirst("WL-Proxy-Client-IP");
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      ip = headers.getFirst("HTTP_CLIENT_IP");
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      ip = headers.getFirst("HTTP_X_FORWARDED_FOR");
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      ip = headers.getFirst("X-Real-IP");
    }
    if (ip == null || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
      InetSocketAddress remoteAddress = request.getRemoteAddress();
      if (remoteAddress != null) {
        ip = remoteAddress.getAddress().getHostAddress();
      }
    }
    return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
  }

  @Data
  private static class GatewayLog {
    /** 访问实例 */
    private String targetServer;
    /** 请求路径 */
    private String requestPath;
    /** 请求方法 */
    private String requestMethod;
    /** 协议 */
    private String schema;
    /** 请求体 */
    private String requestBody;
    /** 响应体 */
    private String responseData;
    /** 请求ip */
    private String ip;
    /** 请求时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss SSS")
    private Date requestTime;
    /** 响应时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss SSS")
    private Date responseTime;
    /** 执行时间 */
    private long executeTime;
  }
}
